home *** CD-ROM | disk | FTP | other *** search
/ Motor Sport Digital Archive Collection 1960s / Motor Sport Digital Archive Collection 1960s.iso / main.swf / scripts / mx / binding / utils / ChangeWatcher.as
Encoding:
Text File  |  2008-05-21  |  4.7 KB  |  175 lines
  1. package mx.binding.utils
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.IEventDispatcher;
  5.    import mx.core.mx_internal;
  6.    import mx.events.PropertyChangeEvent;
  7.    import mx.utils.DescribeTypeCache;
  8.    
  9.    use namespace mx_internal;
  10.    
  11.    public class ChangeWatcher
  12.    {
  13.       mx_internal static const VERSION:String = "2.0.1.0";
  14.       
  15.       private var commitOnly:Boolean;
  16.       
  17.       private var host:Object;
  18.       
  19.       private var handler:Function;
  20.       
  21.       private var getter:Function;
  22.       
  23.       private var name:String;
  24.       
  25.       private var events:Object;
  26.       
  27.       private var next:ChangeWatcher;
  28.       
  29.       public function ChangeWatcher(param1:Object, param2:Function, param3:Boolean = false, param4:ChangeWatcher = null)
  30.       {
  31.          super();
  32.          host = null;
  33.          name = param1 is String ? param1 as String : param1.name;
  34.          getter = param1 is String ? null : param1.getter;
  35.          this.handler = param2;
  36.          this.commitOnly = param3;
  37.          this.next = param4;
  38.          events = {};
  39.       }
  40.       
  41.       private static function isEmpty(param1:Object) : Boolean
  42.       {
  43.          var _loc2_:String = null;
  44.          var _loc3_:int = 0;
  45.          var _loc4_:* = param1;
  46.          for(_loc2_ in _loc4_)
  47.          {
  48.             return false;
  49.          }
  50.          return true;
  51.       }
  52.       
  53.       public static function getEvents(param1:Object, param2:String, param3:Boolean = false) : Object
  54.       {
  55.          var _loc4_:Object = null;
  56.          var _loc5_:Object = null;
  57.          var _loc6_:String = null;
  58.          if(param1 is IEventDispatcher)
  59.          {
  60.             _loc4_ = DescribeTypeCache.describeType(param1).bindabilityInfo.getChangeEvents(param2);
  61.             if(param3)
  62.             {
  63.                _loc5_ = {};
  64.                for(_loc6_ in _loc4_)
  65.                {
  66.                   if(_loc4_[_loc6_])
  67.                   {
  68.                      _loc5_[_loc6_] = true;
  69.                   }
  70.                }
  71.                return _loc5_;
  72.             }
  73.             return _loc4_;
  74.          }
  75.          return {};
  76.       }
  77.       
  78.       public static function watch(param1:Object, param2:Object, param3:Function, param4:Boolean = false) : ChangeWatcher
  79.       {
  80.          var _loc5_:ChangeWatcher = null;
  81.          if(!(param2 is Array))
  82.          {
  83.             param2 = [param2];
  84.          }
  85.          if(param2.length > 0)
  86.          {
  87.             _loc5_ = new ChangeWatcher(param2[0],param3,param4,watch(null,param2.slice(1),param3,param4));
  88.             _loc5_.reset(param1);
  89.             return _loc5_;
  90.          }
  91.          return null;
  92.       }
  93.       
  94.       public static function canWatch(param1:Object, param2:String, param3:Boolean = false) : Boolean
  95.       {
  96.          return !isEmpty(getEvents(param1,param2,param3));
  97.       }
  98.       
  99.       private function getHostPropertyValue() : Object
  100.       {
  101.          return host == null ? null : (getter != null ? getter(host) : host[name]);
  102.       }
  103.       
  104.       public function isWatching() : Boolean
  105.       {
  106.          return !isEmpty(events) && (next == null || next.isWatching());
  107.       }
  108.       
  109.       public function unwatch() : void
  110.       {
  111.          reset(null);
  112.       }
  113.       
  114.       public function setHandler(param1:Function) : void
  115.       {
  116.          this.handler = param1;
  117.          if(next)
  118.          {
  119.             next.setHandler(param1);
  120.          }
  121.       }
  122.       
  123.       private function wrapHandler(param1:Event) : void
  124.       {
  125.          if(next)
  126.          {
  127.             next.reset(getHostPropertyValue());
  128.          }
  129.          if(param1 is PropertyChangeEvent)
  130.          {
  131.             if((param1 as PropertyChangeEvent).property == name)
  132.             {
  133.                handler(param1 as PropertyChangeEvent);
  134.             }
  135.          }
  136.          else
  137.          {
  138.             handler(param1);
  139.          }
  140.       }
  141.       
  142.       public function getValue() : Object
  143.       {
  144.          return host == null ? null : (next == null ? getHostPropertyValue() : next.getValue());
  145.       }
  146.       
  147.       public function reset(param1:Object) : void
  148.       {
  149.          var _loc2_:String = null;
  150.          if(host != null)
  151.          {
  152.             for(_loc2_ in events)
  153.             {
  154.                host.removeEventListener(_loc2_,wrapHandler);
  155.             }
  156.             events = {};
  157.          }
  158.          host = param1;
  159.          if(host != null)
  160.          {
  161.             events = getEvents(host,name,commitOnly);
  162.             for(_loc2_ in events)
  163.             {
  164.                host.addEventListener(_loc2_,wrapHandler);
  165.             }
  166.          }
  167.          if(next)
  168.          {
  169.             next.reset(getHostPropertyValue());
  170.          }
  171.       }
  172.    }
  173. }
  174.  
  175.